
import unittest
from pyramid.config import Configurator
from pyramid import testing
#projectmad

def _initTestingDB():
    from scp.modelo.models import DBSession
    from scp.modelo.models import Base
    from sqlalchemy import create_engine
    engine = create_engine('postgresql://postgres:postgres@localhost:5432/scpbd')
    session = DBSession()
    session.configure(bind=engine)
    Base.metadata.bind = engine
    Base.metadata.create_all(engine)
    return session


class ModelsTestCase(unittest.TestCase):
    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        import transaction
        transaction.abort()
        testing.tearDown()

    def _addUsuario(self, username = u'username'):
        from scp.modelo.models import Usuario
        usuario = Usuario()
        usuario.username = u'username'
        usuario.nombre = u'nombre'
        usuario.apellido = u'apellido'
        usuario.correo = u'correo'
        usuario.password = u'password'
        usuario.estado = u'estado'
        self.session.add(usuario)
        self.session.flush()
        return usuario
        
	"""def _addAtributo(self, nombre = u'nombre'):
		from scp.modelo.models import Atributo
		atributo = Atributo()
		atributo.nombre = u'nombre'
		atributo.tipo_dato = u'tipo_dato'
		atributo.observacion = u'observacion'
		self.session.add(atributo)
		self.session.flush()
		return atributo"""

class TestUsuario(ModelsTestCase):
    def test_add_usuario(self):
        from scp.modelo.models import Usuario
        self._addUsuario()
        
        user = self.session.query(Usuario).filter(Usuario.username == u'username')
        user = user.first()
        self.assertEqual(user.username, u'username')
        self.assertEqual(user.nombre, u'nombre')
        self.assertEqual(user.apellido, u'apellido')
        self.assertEqual(user.correo, u'correo')       
        self.assertEqual(user.password, u'password')
        self.assertEqual(user.estado, u'estado')
        

    def test_doesnt_exitst(self):
        from scp.modelo.models import Usuario
        from sqlalchemy.orm.exc import NoResultFound
        query = self.session.query(Usuario).filter(Usuario.username == u'nobody')
        self.assertRaises(NoResultFound, query.one)

    def test_arleady_exist(self):
        from sqlalchemy.exc import IntegrityError
        self._addUsuario()
        self.assertRaises(IntegrityError, self._addUsuario)

class ModelsTestCase1(unittest.TestCase):
    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        import transaction
        transaction.abort()
        testing.tearDown()

    def _addAtributo(self, nombre = u'nombre'):
		from scp.modelo.models import Atributo
		atributo = Atributo()
		atributo.nombre = u'nombre'
		atributo.tipo_dato = u'tipo_dato'
		atributo.observacion = u'observacion'
		self.session.add(atributo)
		self.session.flush()
		return atributo

class TestAtributo(ModelsTestCase1):
    def test_add_atributo(self):
		from scp.modelo.models import Atributo

		self._addAtributo()
		atrib = self.session.query(Atributo).filter(Atributo.nombre == u'nombre')
		atrib = atrib.first()
		self.assertEqual(atrib.nombre, u'nombre')
		self.assertEqual(atrib.tipo_dato, u'tipo_dato')
		self.assertEqual(atrib.observacion, u'observacion')

    def test_doesnt_exitst(self):
        from scp.modelo.models import Atributo
        from sqlalchemy.orm.exc import NoResultFound
        query = self.session.query(Atributo).filter(Atributo.nombre == u'nobody')
        self.assertRaises(NoResultFound, query.one)

    def test_arleady_exist(self):
        from sqlalchemy.exc import IntegrityError
        self._addAtributo()
        self.assertRaises(IntegrityError, self._addAtributo)

class ModelsTestCase2(unittest.TestCase):
    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        import transaction
        transaction.abort()
        testing.tearDown()

    def _addProyecto(self, nombre = u'nombre'):
        from scp.modelo.models import Proyecto
        proyecto = Proyecto()
        proyecto.nombre = u'nombre'
        proyecto.descripcion = u'descripcion'
        proyecto.fecha_inicio = u'fecha_inicio'
        proyecto.estado = u'estado'
        self.session.add(proyecto)
        self.session.flush()
        return proyecto
        

class TestUProyecto(ModelsTestCase2):
    def test_add_proyecto(self):
        from scp.modelo.models import Proyecto
        self._addProyecto()
        
        proy = self.session.query(Proyecto).filter(Proyecto.nombre == u'nombre')
        proy = proy.first()
        self.assertEqual(proy.nombre, u'nombre')
        self.assertEqual(proy.descripcion, u'descripcion')
        self.assertEqual(proy.fecha_inicio, u'fecha_inicio')
        self.assertEqual(proy.estado, u'estado')
        

    def test_doesnt_exitst(self):
        from scp.modelo.models import Proyecto
        from sqlalchemy.orm.exc import NoResultFound
        query = self.session.query(Proyecto).filter(Proyecto.nombre == u'nobody')
        self.assertRaises(NoResultFound, query.one)

    def test_arleady_exist(self):
        from sqlalchemy.exc import IntegrityError
        self._addProyecto()
        self.assertRaises(IntegrityError, self._addProyecto)


class ModelsTestCase3(unittest.TestCase):
    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        import transaction
        transaction.abort()
        testing.tearDown()

    def _addFase(self, nombre = u'nombre'):
        from scp.modelo.models import Fase
        fase = Fase()
        fase.nombre = u'nombre'
        fase.descripcion = u'descripcion'
        fase.fecha_inicio = u'fecha_inicio'
        fase.fecha_fin = u'fecha_fin'
        fase.observacion = u'observacion'
        fase.estado = u'estado'
        
        self.session.add(fase)
        self.session.flush()
        return fase

class TestFase(ModelsTestCase3):
    def test_add_fase(self):
        from scp.modelo.models import Fase
        self._addFase()
        
        fase = self.session.query(Fase).filter(Fase.nombre == u'nombre')
        fase = fase.first()
        self.assertEqual(fase.nombre, u'nombre')
        self.assertEqual(fase.descripcion, u'descripcion')
        self.assertEqual(fase.fecha_inicio, u'fecha_inicio')       
        self.assertEqual(fase.fecha_fin, u'fecha_fin')
        self.assertEqual(fase.observacion, u'observacion')
        self.assertEqual(fase.estado, u'estado')
        

    def test_doesnt_exitst(self):
        from scp.modelo.models import Fase
        from sqlalchemy.orm.exc import NoResultFound
        query = self.session.query(Fase).filter(Fase.nombre == u'nobody')
        self.assertRaises(NoResultFound, query.one)

    def test_arleady_exist(self):
        from sqlalchemy.exc import IntegrityError
        self._addFase()
        self.assertRaises(IntegrityError, self._addFase)

class ModelsTestCase4(unittest.TestCase):
    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        import transaction
        transaction.abort()
        testing.tearDown()

    def _addRol(self, nombre = u'nombre'):
        from scp.modelo.models import Rol
        rol = Rol()
        rol.nombre = u'nombre'
        rol.descripcion = u'descripcion'
        self.session.add(rol)
        self.session.flush()
        return rol

class TestRol(ModelsTestCase4):
    def test_add_rol(self):
        from scp.modelo.models import Rol
        self._addRol()
        
        rol = self.session.query(Rol).filter(Rol.nombre == u'nombre')
        rol = rol.first()
        self.assertEqual(rol.nombre, u'nombre')
        self.assertEqual(rol.descripcion, u'descripcion')

    def test_doesnt_exitst(self):
        from scp.modelo.models import Rol
        from sqlalchemy.orm.exc import NoResultFound
        query = self.session.query(Rol).filter(Rol.nombre == u'nobody')
        self.assertRaises(NoResultFound, query.one)

    def test_arleady_exist(self):
        from sqlalchemy.exc import IntegrityError
        self._addRol()
        self.assertRaises(IntegrityError, self._addRol)

class ModelsTestCase5(unittest.TestCase):
    def setUp(self):
        self.session = _initTestingDB()

    def tearDown(self):
        import transaction
        transaction.abort()
        testing.tearDown()

    def _addTipo_Item(self, nombre = u'nombre'):
        from scp.modelo.models import Tipo_Item
        tipoItem = Tipo_Item()
        tipoItem.nombre = u'nombre'
        tipoItem.descripcion = u'descripcion'
        tipoItem.observacion = u'observacion'
        self.session.add(tipoItem)
        self.session.flush()
        return tipoItem

class TestTipo_Item(ModelsTestCase5):
    def test_add_tipoItem(self):
        from scp.modelo.models import Tipo_Item
        self._addTipo_Item()
        
        tipoItem = self.session.query(Tipo_Item).filter(Tipo_Item.nombre == u'nombre')
        tipoItem = tipoItem.first()
        self.assertEqual(tipoItem.nombre, u'nombre')
        self.assertEqual(tipoItem.descripcion, u'descripcion')
        self.assertEqual(tipoItem.observacion, u'observacion')   

    def test_doesnt_exitst(self):
        from scp.modelo.models import Tipo_Item
        from sqlalchemy.orm.exc import NoResultFound
        query = self.session.query(Tipo_Item).filter(Tipo_Item.nombre == u'nobody')
        self.assertRaises(NoResultFound, query.one)

    def test_arleady_exist(self):
        from sqlalchemy.exc import IntegrityError
        self._addTipo_Item()
        self.assertRaises(IntegrityError, self._addTipo_Item)
